package SBD.CRUD;

import SBD.Servicios.Conexion;
import SBD.Servicios.FactoriaServicios;
import EP.MetricasContenido.Euclidiana;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
* @class EuclidianaBD
* @author Mauricio Alvarez.
* @brief Realiza las operaciones de CRUD correspondientes a la métrica euclidiana.
*/
public class EuclidianaBD
{

    //////////////////////
    // OPERACIONES
    //////////////////////

    /**
     * @brief Guarda los resultados de la medición de similitud euclidiana para el body.
     * @param El listado de los puntajes de todas las métricas de ranking, el TopicoConsultado, Umbral y Ranking.
     * @return void
    */
    public void GuardarSimilitudEuclidiana(Map<Integer, List> ResultadosSETF_SN,
                                           Map<Integer, List> ResultadosSETF_N,
                                           Map<Integer, List> ResultadosSETF_S,
                                           Map<Integer, List> ResultadosSETFIDF_SN,
                                           Map<Integer, List> ResultadosSETFIDF_N,
                                           Map<Integer, List> ResultadosSETFIDF_S,
                                           Map<Integer, List> ResultadosSETFIDF_O_SN,
                                           Map<Integer, List> ResultadosSETFIDF_O_N,
                                           Map<Integer, List> ResultadosSETFIDF_O_S,
                                           Map<Integer, List> ResultadosSEOKAPI,
                                           String TopicoConsultado,
                                           double Umbral,
                                           int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {

        //Atributos:
        int id_pagina;
        String termino;
        int id_pagina_objetivo;
        String url_test;
        String url_objetivo;
        double valor_se;

        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        //Se guardan los parametros de la medición en la tabla SIMILITUD_EUCLIDIANA:
        cdb.un_sql = "INSERT INTO SIMILITUD_EUCLIDIANA(termino, umbral, ranking) VALUES"
                + "('" + TopicoConsultado + "','" +  Umbral + "','" + Ranking + "')";
        cdb.un_st.executeUpdate(cdb.un_sql);
        //El ultimo registro ingresado a la Tabla:
        cdb.un_sql = "SELECT id_se FROM SIMILITUD_EUCLIDIANA ORDER BY id_se DESC LIMIT 1";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                //Se obtiene el id correspondiente a la medicion se:
                int id_se = cdb.resultado.getInt("id_se");


                //Se guardan los resultados de la medición:
                ////////////////////////////////
                // (1) Similitud Euclidiana TF_SN
                ////////////////////////////////

                Set set = ResultadosSETF_SN.entrySet();
                Iterator iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SE>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_pagina:
                    id_pagina = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SE>:
                    List<Euclidiana> ListaSETF_SN = new ArrayList();
                    ListaSETF_SN = (List<Euclidiana>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSETF_SN.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        termino = ListaSETF_SN.get(i).getTermino();
                        id_pagina_objetivo = ListaSETF_SN.get(i).getId_pagina_objetivo();
                        url_test = ListaSETF_SN.get(i).getUrl_test();
                        url_objetivo = ListaSETF_SN.get(i).getUrl_objetivo();
                        valor_se = ListaSETF_SN.get(i).getValor_se();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SETF_SN("
                                + "id_pagina, "
                                + "id_se, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "setf_sn) "
                                + "VALUES ('" + id_pagina + "','"
                                              + id_se + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_se + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores se

                }//FIN while páginas


                ////////////////////////////////
                // (2) Similitud Euclidiana TF_N
                ////////////////////////////////
                set = ResultadosSETF_N.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SE>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_pagina:
                    id_pagina = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SE>:
                    List<Euclidiana> ListaSETF_N = new ArrayList();
                    ListaSETF_N = (List<Euclidiana>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSETF_N.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        termino = ListaSETF_N.get(i).getTermino();
                        id_pagina_objetivo = ListaSETF_N.get(i).getId_pagina();
                        url_test = ListaSETF_N.get(i).getUrl_test();
                        url_objetivo = ListaSETF_N.get(i).getUrl_objetivo();
                        valor_se = ListaSETF_N.get(i).getValor_se();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SETF_N("
                                + "id_pagina, "
                                + "id_se, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "setf_n) "
                                + "VALUES ('" + id_pagina + "','"
                                              + id_se + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_se + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores se

                }//FIN while páginas



                ////////////////////////////////
                // (3) Similitud Euclidiana TF_S
                ////////////////////////////////
                set = ResultadosSETF_S.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SE>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_pagina:
                    id_pagina = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SE>:
                    List<Euclidiana> ListaSETF_S = new ArrayList();
                    ListaSETF_S = (List<Euclidiana>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSETF_S.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        termino = ListaSETF_S.get(i).getTermino();
                        id_pagina_objetivo = ListaSETF_S.get(i).getId_pagina_objetivo();
                        url_test = ListaSETF_S.get(i).getUrl_test();
                        url_objetivo = ListaSETF_S.get(i).getUrl_objetivo();
                        valor_se = ListaSETF_S.get(i).getValor_se();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SETF_S("
                                + "id_pagina, "
                                + "id_se, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "setf_s) "
                                + "VALUES ('" + id_pagina + "','"
                                              + id_se + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_se + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores se

                }//FIN while páginas



                //////////////////////////////////
                // (4) Similitud Euclidiana TFIDF_SN
                //////////////////////////////////
                set = ResultadosSETFIDF_SN.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SE>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_pagina:
                    id_pagina = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SE>:
                    List<Euclidiana> ListaSETFIDF_SN = new ArrayList();
                    ListaSETFIDF_SN = (List<Euclidiana>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSETFIDF_SN.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        termino = ListaSETFIDF_SN.get(i).getTermino();
                        id_pagina_objetivo = ListaSETFIDF_SN.get(i).getId_pagina_objetivo();
                        url_test = ListaSETFIDF_SN.get(i).getUrl_test();
                        url_objetivo = ListaSETFIDF_SN.get(i).getUrl_objetivo();
                        valor_se = ListaSETFIDF_SN.get(i).getValor_se();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SETFIDF_SN("
                                + "id_pagina, "
                                + "id_se, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "setfidf_sn) "
                                + "VALUES ('" + id_pagina + "','"
                                              + id_se + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_se + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores se

                }//FIN while páginas



                //////////////////////////////////
                // (5) Similitud Euclidiana TFIDF_N
                //////////////////////////////////
                set = ResultadosSETFIDF_N.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SE>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_pagina:
                    id_pagina = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SE>:
                    List<Euclidiana> ListaSETFIDF_N = new ArrayList();
                    ListaSETFIDF_N = (List<Euclidiana>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSETFIDF_N.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        termino = ListaSETFIDF_N.get(i).getTermino();
                        id_pagina_objetivo = ListaSETFIDF_N.get(i).getId_pagina_objetivo();
                        url_test = ListaSETFIDF_N.get(i).getUrl_test();
                        url_objetivo = ListaSETFIDF_N.get(i).getUrl_objetivo();
                        valor_se = ListaSETFIDF_N.get(i).getValor_se();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SETFIDF_N("
                                + "id_pagina, "
                                + "id_se, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "setfidf_n) "
                                + "VALUES ('" + id_pagina + "','"
                                              + id_se + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_se + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores se

                }//FIN while páginas




                //////////////////////////////////
                // (6) Similitud Euclidiana TFIDF_S
                //////////////////////////////////
                set = ResultadosSETFIDF_S.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SE>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_pagina:
                    id_pagina = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SE>:
                    List<Euclidiana> ListaSETFIDF_S = new ArrayList();
                    ListaSETFIDF_S = (List<Euclidiana>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSETFIDF_S.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        termino = ListaSETFIDF_S.get(i).getTermino();
                        id_pagina_objetivo = ListaSETFIDF_S.get(i).getId_pagina_objetivo();
                        url_test = ListaSETFIDF_S.get(i).getUrl_test();
                        url_objetivo = ListaSETFIDF_S.get(i).getUrl_objetivo();
                        valor_se = ListaSETFIDF_S.get(i).getValor_se();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SETFIDF_S("
                                + "id_pagina, "
                                + "id_se, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "setfidf_s) "
                                + "VALUES ('" + id_pagina + "','"
                                              + id_se + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_se + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores se

                }//FIN while páginas




                ////////////////////////////////////
                // (7) Similitud Euclidiana TFIDF_O_SN
                ////////////////////////////////////
                set = ResultadosSETFIDF_O_SN.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SE>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_pagina:
                    id_pagina = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SE>:
                    List<Euclidiana> ListaSETFIDF_O_SN = new ArrayList();
                    ListaSETFIDF_O_SN = (List<Euclidiana>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSETFIDF_O_SN.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        termino = ListaSETFIDF_O_SN.get(i).getTermino();
                        id_pagina_objetivo = ListaSETFIDF_O_SN.get(i).getId_pagina_objetivo();
                        url_test= ListaSETFIDF_O_SN.get(i).getUrl_test();
                        url_objetivo = ListaSETFIDF_O_SN.get(i).getUrl_objetivo();
                        valor_se = ListaSETFIDF_O_SN.get(i).getValor_se();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SETFIDF_O_SN("
                                + "id_pagina, "
                                + "id_se, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "setfidf_o_sn) "
                                + "VALUES ('" + id_pagina + "','"
                                              + id_se + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_se + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores se

                }//FIN while páginas




                ////////////////////////////////////
                // (8) Similitud Euclidiana TFIDF_O_N
                ////////////////////////////////////
                set = ResultadosSETFIDF_O_N.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SE>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_pagina:
                    id_pagina = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SE>:
                    List<Euclidiana> ListaSETFIDF_O_N = new ArrayList();
                    ListaSETFIDF_O_N = (List<Euclidiana>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSETFIDF_O_N.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        termino = ListaSETFIDF_O_N.get(i).getTermino();
                        id_pagina_objetivo = ListaSETFIDF_O_N.get(i).getId_pagina_objetivo();
                        url_test = ListaSETFIDF_O_N.get(i).getUrl_test();
                        url_objetivo = ListaSETFIDF_O_N.get(i).getUrl_objetivo();
                        valor_se = ListaSETFIDF_O_N.get(i).getValor_se();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SETFIDF_O_N("
                                + "id_pagina, "
                                + "id_se, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "setfidf_o_n) "
                                + "VALUES ('" + id_pagina + "','"
                                              + id_se + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_se + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores se

                }//FIN while páginas




                ////////////////////////////////////
                // (9) Similitud Euclidiana TFIDF_O_S
                ////////////////////////////////////
                set = ResultadosSETFIDF_O_N.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SE>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_pagina:
                    id_pagina = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SE>:
                    List<Euclidiana> ListaSETFIDF_O_S = new ArrayList();
                    ListaSETFIDF_O_S = (List<Euclidiana>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSETFIDF_O_S.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        termino = ListaSETFIDF_O_S.get(i).getTermino();
                        id_pagina_objetivo = ListaSETFIDF_O_S.get(i).getId_pagina_objetivo();
                        url_test = ListaSETFIDF_O_S.get(i).getUrl_test();
                        url_objetivo = ListaSETFIDF_O_S.get(i).getUrl_objetivo();
                        valor_se = ListaSETFIDF_O_S.get(i).getValor_se();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SETFIDF_O_S("
                                + "id_pagina, "
                                + "id_se, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "setfidf_o_s) "
                                + "VALUES ('" + id_pagina + "','"
                                              + id_se + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_se + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores sc

                }//FIN while páginas



                ////////////////////////////////////
                // (10) Similitud Euclidiana OKAPI
                ////////////////////////////////////
                set = ResultadosSEOKAPI.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SE>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_pagina:
                    id_pagina = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SE>:
                    List<Euclidiana> ListaSEOKAPI = new ArrayList();
                    ListaSEOKAPI = (List<Euclidiana>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSEOKAPI.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        termino = ListaSEOKAPI.get(i).getTermino();
                        id_pagina_objetivo = ListaSEOKAPI.get(i).getId_pagina_objetivo();
                        url_test = ListaSEOKAPI.get(i).getUrl_test();
                        url_objetivo = ListaSEOKAPI.get(i).getUrl_objetivo();
                        valor_se = ListaSEOKAPI.get(i).getValor_se();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SEOKAPI("
                                + "id_pagina, "
                                + "id_se, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "seokapi) "
                                + "VALUES ('" + id_pagina + "','"
                                              + id_se + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_se + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores se

                }//FIN while páginas


            }//FIN if
        }



    }//FIN GuardarSimilitudEuclidiana


    /**
     * @brief Rankea los resultados obtenidos por la medición euclidiana para las páginas.
     * @param Cantidad en el Ranking y la Consulta .
     * @return void
    */
    public void RankearMedicionSE(int Ranking, String Consulta) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {

        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        ////////////////////////////////////////////////////////
        //PASO 1: Se cargan las páginas segun ranking y umbral
        ////////////////////////////////////////////////////////
        int rankeo  = 1;
        int contador = 0;
        //Almacena <id_pagina, rankeo>:
        HashMap<Integer,Integer> RankingPagina;
        //Fecha actual:
        java.util.Date fecha = new Date();


        ///////////////////////
        // (1) PARA SETF_SN
        ///////////////////////

        //Almacena <id_pagina, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SETF_SN ORDER BY setf_sn ASC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            PrintWriter fileout = new PrintWriter(new FileWriter("RankingSETF_SN.txt", true));

            fileout.println("*******************************************");
            fileout.println("**  RANKING SIMILITUD EUCLIDIANA TF_SN   **");
            fileout.println("*******************************************");
            fileout.println();
            fileout.println("FECHA: "+ fecha);
            fileout.println();
            fileout.println("CONSULTA: "+ Consulta);
            fileout.println();
            fileout.println("***************************************");

            while (cdb.resultado.next())
            {
                try {

                   int id_pagina = cdb.resultado.getInt("id_pagina");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double setf_sn = cdb.resultado.getDouble("setf_sn");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      fileout.println("Posición: "+ rankeo);
                      fileout.println("id_pagina: " + id_pagina);
                      fileout.println("id_pagina_objetivo: "+ id_pagina_objetivo);
                      fileout.println("url_test: "+ url_test);
                      fileout.println("url_objetivo: "+ url_objetivo);
                      fileout.println("setf_sn: "+ setf_sn);
                      fileout.println("***************************************");
                      contador++;
                   }

                   RankingPagina.put(id_pagina, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SETF_SN.");
                }

            }
            fileout.close();
        }

        // Se Actualiza el raking:
        ActualizarRankingSETF_SN(RankingPagina);


        ///////////////////////
        // (2) PARA SETF_N
        ///////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_pagina, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SETF_N ORDER BY setf_n ASC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            PrintWriter fileout = new PrintWriter(new FileWriter("RankingSETF_N.txt", true));

            fileout.println("*******************************************");
            fileout.println("**  RANKING SIMILITUD EUCLIDIANA TF_N    **");
            fileout.println("*******************************************");
            fileout.println();
            fileout.println("FECHA: "+ fecha);
            fileout.println();
            fileout.println("CONSULTA: "+ Consulta);
            fileout.println();
            fileout.println("***************************************");

            while (cdb.resultado.next())
            {
                try {

                   int id_pagina = cdb.resultado.getInt("id_pagina");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double setf_n = cdb.resultado.getDouble("setf_n");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      fileout.println("Posición: "+ rankeo);
                      fileout.println("id_pagina: " + id_pagina);
                      fileout.println("id_pagina_objetivo: "+ id_pagina_objetivo);
                      fileout.println("url_test: "+ url_test);
                      fileout.println("url_objetivo: "+ url_objetivo);
                      fileout.println("setf_n: "+ setf_n);
                      fileout.println("***************************************");
                      contador++;
                   }

                   RankingPagina.put(id_pagina, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SETF_N.");
                }

            }
            fileout.close();
        }

        // Se Actualiza el raking:
        ActualizarRankingSETF_N(RankingPagina);


        ///////////////////////
        // (3) PARA SETF_S
        ///////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_pagina, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SETF_S ORDER BY setf_s ASC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            PrintWriter fileout = new PrintWriter(new FileWriter("RankingSETF_S.txt", true));

            fileout.println("*******************************************");
            fileout.println("**  RANKING SIMILITUD EUCLIDIANA TF_S    **");
            fileout.println("*******************************************");
            fileout.println();
            fileout.println("FECHA: "+ fecha);
            fileout.println();
            fileout.println("CONSULTA: "+ Consulta);
            fileout.println();
            fileout.println("***************************************");

            while (cdb.resultado.next())
            {
                try {

                   int id_pagina = cdb.resultado.getInt("id_pagina");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double setf_s = cdb.resultado.getDouble("setf_s");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      fileout.println("Posición: "+ rankeo);
                      fileout.println("id_pagina: " + id_pagina);
                      fileout.println("id_pagina_objetivo: "+ id_pagina_objetivo);
                      fileout.println("url_test: "+ url_test);
                      fileout.println("url_objetivo: "+ url_objetivo);
                      fileout.println("setf_s: "+ setf_s);
                      fileout.println("***************************************");
                      contador++;
                   }

                   RankingPagina.put(id_pagina, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SETF_S.");
                }

            }
            fileout.close();
        }

        // Se Actualiza el raking:
        ActualizarRankingSETF_S(RankingPagina);


        /////////////////////////
        // (4) PARA SETFIDF_SN
        /////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_pagina, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SETFIDF_SN ORDER BY setfidf_sn ASC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            PrintWriter fileout = new PrintWriter(new FileWriter("RankingSETFIDF_SN.txt", true));

            fileout.println("***********************************************");
            fileout.println("**  RANKING SIMILITUD EUCLIDIANA TFIDF_SN    **");
            fileout.println("***********************************************");
            fileout.println();
            fileout.println("FECHA: "+ fecha);
            fileout.println();
            fileout.println("CONSULTA: "+ Consulta);
            fileout.println();
            fileout.println("***************************************");

            while (cdb.resultado.next())
            {
                try {

                   int id_pagina = cdb.resultado.getInt("id_pagina");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double setfidf_sn = cdb.resultado.getDouble("setfidf_sn");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      fileout.println("Posición: "+ rankeo);
                      fileout.println("id_pagina: " + id_pagina);
                      fileout.println("id_pagina_objetivo: "+ id_pagina_objetivo);
                      fileout.println("url_test: "+ url_test);
                      fileout.println("url_objetivo: "+ url_objetivo);
                      fileout.println("setfidf_sn: "+ setfidf_sn);
                      fileout.println("***************************************");
                      contador++;
                   }

                   RankingPagina.put(id_pagina, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SETFIDF_SN .");
                }

            }
            fileout.close();
        }

        // Se Actualiza el raking:
        ActualizarRankingSETFIDF_SN (RankingPagina);


        /////////////////////////
        // (5) PARA SETFIDF_N
        /////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_pagina, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SETFIDF_N ORDER BY setfidf_n ASC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            PrintWriter fileout = new PrintWriter(new FileWriter("RankingSETFIDF_N.txt", true));

            fileout.println("***********************************************");
            fileout.println("**  RANKING SIMILITUD EUCLIDIANA TFIDF_N     **");
            fileout.println("***********************************************");
            fileout.println();
            fileout.println("FECHA: "+ fecha);
            fileout.println();
            fileout.println("CONSULTA: "+ Consulta);
            fileout.println();
            fileout.println("***************************************");

            while (cdb.resultado.next())
            {
                try {

                   int id_pagina = cdb.resultado.getInt("id_pagina");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double setfidf_n = cdb.resultado.getDouble("setfidf_n");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      fileout.println("Posición: "+ rankeo);
                      fileout.println("id_pagina: " + id_pagina);
                      fileout.println("id_pagina_objetivo: "+ id_pagina_objetivo);
                      fileout.println("url_test: "+ url_test);
                      fileout.println("url_objetivo: "+ url_objetivo);
                      fileout.println("setfidf_n: "+ setfidf_n);
                      fileout.println("***************************************");
                      contador++;
                   }

                   RankingPagina.put(id_pagina, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SETFIDF_N .");
                }

            }
            fileout.close();
        }

        // Se Actualiza el raking:
        ActualizarRankingSETFIDF_N(RankingPagina);



        /////////////////////////
        // (6) PARA SETFIDF_S
        /////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_pagina, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SETFIDF_S ORDER BY setfidf_s ASC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            PrintWriter fileout = new PrintWriter(new FileWriter("RankingSETFIDF_S.txt", true));

            fileout.println("***********************************************");
            fileout.println("**  RANKING SIMILITUD EUCLIDIANA TFIDF_S     **");
            fileout.println("***********************************************");
            fileout.println();
            fileout.println("FECHA: "+ fecha);
            fileout.println();
            fileout.println("CONSULTA: "+ Consulta);
            fileout.println();
            fileout.println("***************************************");

            while (cdb.resultado.next())
            {
                try {

                   int id_pagina = cdb.resultado.getInt("id_pagina");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double setfidf_s = cdb.resultado.getDouble("setfidf_s");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      fileout.println("Posición: "+ rankeo);
                      fileout.println("id_pagina: " + id_pagina);
                      fileout.println("id_pagina_objetivo: "+ id_pagina_objetivo);
                      fileout.println("url_test: "+ url_test);
                      fileout.println("url_objetivo: "+ url_objetivo);
                      fileout.println("setfidf_s: "+ setfidf_s);
                      fileout.println("***************************************");
                      contador++;
                   }

                   RankingPagina.put(id_pagina, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SETFIDF_S .");
                }

            }
            fileout.close();
        }

        // Se Actualiza el raking:
        ActualizarRankingSETFIDF_S(RankingPagina);



        ////////////////////////////
        // (7) PARA SETFIDF_O_SN
        ////////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_pagina, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SETFIDF_O_SN ORDER BY setfidf_o_sn ASC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            PrintWriter fileout = new PrintWriter(new FileWriter("RankingSETFIDF_O_SN.txt", true));

            fileout.println("**************************************************");
            fileout.println("**  RANKING SIMILITUD EUCLIDIANA TFIDF_O_SN     **");
            fileout.println("**************************************************");
            fileout.println();
            fileout.println("FECHA: "+ fecha);
            fileout.println();
            fileout.println("CONSULTA: "+ Consulta);
            fileout.println();
            fileout.println("***************************************");

            while (cdb.resultado.next())
            {
                try {

                   int id_pagina = cdb.resultado.getInt("id_pagina");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double setfidf_o_sn = cdb.resultado.getDouble("setfidf_o_sn");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      fileout.println("Posición: "+ rankeo);
                      fileout.println("id_pagina: " + id_pagina);
                      fileout.println("id_pagina_objetivo: "+ id_pagina_objetivo);
                      fileout.println("url_test: "+ url_test);
                      fileout.println("url_objetivo: "+ url_objetivo);
                      fileout.println("setfidf_o_sn: "+ setfidf_o_sn);
                      fileout.println("***************************************");
                      contador++;
                   }

                   RankingPagina.put(id_pagina, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SETFIDF_O_SN .");
                }

            }
            fileout.close();
        }

        // Se Actualiza el raking:
        ActualizarRankingSETFIDF_O_SN(RankingPagina);



        ////////////////////////////
        // (8) PARA SETFIDF_O_N
        ////////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_pagina, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SETFIDF_O_N ORDER BY setfidf_o_n ASC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            PrintWriter fileout = new PrintWriter(new FileWriter("RankingSETFIDF_O_N.txt", true));

            fileout.println("**************************************************");
            fileout.println("**  RANKING SIMILITUD EUCLIDIANA TFIDF_O_N      **");
            fileout.println("**************************************************");
            fileout.println();
            fileout.println("FECHA: "+ fecha);
            fileout.println();
            fileout.println("CONSULTA: "+ Consulta);
            fileout.println();
            fileout.println("***************************************");

            while (cdb.resultado.next())
            {
                try {

                   int id_pagina = cdb.resultado.getInt("id_pagina");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double setfidf_o_n = cdb.resultado.getDouble("setfidf_o_n");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      fileout.println("Posición: "+ rankeo);
                      fileout.println("id_pagina: " + id_pagina);
                      fileout.println("id_pagina_objetivo: "+ id_pagina_objetivo);
                      fileout.println("url_test: "+ url_test);
                      fileout.println("url_objetivo: "+ url_objetivo);
                      fileout.println("setfidf_o_n: "+ setfidf_o_n);
                      fileout.println("***************************************");
                      contador++;
                   }

                   RankingPagina.put(id_pagina, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SETFIDF_O_N .");
                }

            }
            fileout.close();
        }

        // Se Actualiza el raking:
        ActualizarRankingSETFIDF_O_N(RankingPagina);



        ////////////////////////////
        // (9) PARA SETFIDF_O_S
        ////////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_pagina, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SETFIDF_O_S ORDER BY setfidf_o_s ASC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            PrintWriter fileout = new PrintWriter(new FileWriter("RankingSETFIDF_O_S.txt", true));

            fileout.println("**************************************************");
            fileout.println("**  RANKING SIMILITUD EUCLIDIANA TFIDF_O_S      **");
            fileout.println("**************************************************");
            fileout.println();
            fileout.println("FECHA: "+ fecha);
            fileout.println();
            fileout.println("CONSULTA: "+ Consulta);
            fileout.println();
            fileout.println("***************************************");

            while (cdb.resultado.next())
            {
                try {

                   int id_pagina = cdb.resultado.getInt("id_pagina");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double setfidf_o_s = cdb.resultado.getDouble("setfidf_o_s");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      fileout.println("Posición: "+ rankeo);
                      fileout.println("id_pagina: " + id_pagina);
                      fileout.println("id_pagina_objetivo: "+ id_pagina_objetivo);
                      fileout.println("url_test: "+ url_test);
                      fileout.println("url_objetivo: "+ url_objetivo);
                      fileout.println("setfidf_o_s: "+ setfidf_o_s);
                      fileout.println("***************************************");
                      contador++;
                   }

                   RankingPagina.put(id_pagina, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SETFIDF_O_S .");
                }

            }
            fileout.close();
        }

        // Se Actualiza el raking:
        ActualizarRankingSETFIDF_O_S(RankingPagina);



        ////////////////////////////
        // (10) PARA SEOKAPI
        ////////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_pagina, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SEOKAPI ORDER BY seokapi ASC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            PrintWriter fileout = new PrintWriter(new FileWriter("RankingSEOKAPI.txt", true));

            fileout.println("**************************************************");
            fileout.println("**  RANKING SIMILITUD EUCLIDIANA OKAPI          **");
            fileout.println("**************************************************");
            fileout.println();
            fileout.println("FECHA: "+ fecha);
            fileout.println();
            fileout.println("CONSULTA: "+ Consulta);
            fileout.println();  
            fileout.println("***************************************");

            while (cdb.resultado.next())
            {
                try {

                   int id_pagina = cdb.resultado.getInt("id_pagina");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double seokapi = cdb.resultado.getDouble("seokapi");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      fileout.println("Posición: "+ rankeo);
                      fileout.println("id_pagina: " + id_pagina);
                      fileout.println("id_pagina_objetivo: "+ id_pagina_objetivo);
                      fileout.println("url_test: "+ url_test);
                      fileout.println("url_objetivo: "+ url_objetivo);
                      fileout.println("seokapi: "+ seokapi);
                      fileout.println("***************************************");
                      contador++;
                   }

                   RankingPagina.put(id_pagina, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SEOKAPI .");
                }

            }
            fileout.close();
        }

        // Se Actualiza el raking:
        ActualizarRankingSEOKAPI(RankingPagina);



    }//FIN RankearMedicionSE



    private void ActualizarRankingSETF_SN(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SETF_SN SET ranking_setf_sn = '" + me.getValue() + "' WHERE id_pagina = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSETF_SN


    private void ActualizarRankingSETF_N(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SETF_N SET ranking_setf_n = '" + me.getValue() + "' WHERE id_pagina = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSETF_N



    private void ActualizarRankingSETF_S(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SETF_S SET ranking_setf_s = '" + me.getValue() + "' WHERE id_pagina = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSETF_S



    private void ActualizarRankingSETFIDF_SN(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SETFIDF_SN SET ranking_setfidf_sn = '" + me.getValue() + "' WHERE id_pagina = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSETFIDF_SN



    private void ActualizarRankingSETFIDF_N(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SETFIDF_N SET ranking_setfidf_n = '" + me.getValue() + "' WHERE id_pagina = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSETFIDF_N



    private void ActualizarRankingSETFIDF_S(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SETFIDF_S SET ranking_setfidf_s = '" + me.getValue() + "' WHERE id_pagina = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSETFIDF_S



    private void ActualizarRankingSETFIDF_O_SN(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SETFIDF_O_SN SET ranking_setfidf_o_sn = '" + me.getValue() + "' WHERE id_pagina = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSETFIDF_O_SN



    private void ActualizarRankingSETFIDF_O_N(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SETFIDF_O_N SET ranking_setfidf_o_n = '" + me.getValue() + "' WHERE id_pagina = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSETFIDF_O_N



    private void ActualizarRankingSETFIDF_O_S(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SETFIDF_O_S SET ranking_setfidf_o_s = '" + me.getValue() + "' WHERE id_pagina = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSETFIDF_O_S



    private void ActualizarRankingSEOKAPI(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SEOKAPI SET ranking_seokapi = '" + me.getValue() + "' WHERE id_pagina = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSEOKAPI


    /**
     * @brief Guarda los resultados de la medición de similitud euclidiana para el texto alrededor.
     * @param El listado de los puntajes de todas las métricas de ranking, el TopicoConsultado, Umbral y Ranking.
     * @return void
    */
    public void GuardarSimilitudEuclidiana_ST(Map<Integer, List> ResultadosSETF_SN_ST,
                                              Map<Integer, List> ResultadosSETF_N_ST,
                                              Map<Integer, List> ResultadosSETF_S_ST,
                                              Map<Integer, List> ResultadosSETFIDF_SN_ST,
                                              Map<Integer, List> ResultadosSETFIDF_N_ST,
                                              Map<Integer, List> ResultadosSETFIDF_S_ST,
                                              Map<Integer, List> ResultadosSETFIDF_O_SN_ST,
                                              Map<Integer, List> ResultadosSETFIDF_O_N_ST,
                                              Map<Integer, List> ResultadosSETFIDF_O_S_ST,
                                              Map<Integer, List> ResultadosSEOKAPI_ST,
                                              String TopicoConsultado,
                                              double Umbral,
                                              int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {

        //Atributos:
        int id_relacion_pag;
        int id_pagina_objetivo;
        String url_test;
        String url_objetivo;
        String termino;
        double valor_se;

        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        //Se guardan los parametros de la medición en la tabla SIMILITUD_EUCLIDIANA:
        cdb.un_sql = "INSERT INTO SIMILITUD_EUCLIDIANA_ST (termino, umbral, ranking) VALUES"
                + "('" + TopicoConsultado + "','" +  Umbral + "','" + Ranking + "')";
        cdb.un_st.executeUpdate(cdb.un_sql);
        //El ultimo registro ingresado a la Tabla:
        cdb.un_sql = "SELECT id_se_st FROM SIMILITUD_EUCLIDIANA_ST ORDER BY id_se_st DESC LIMIT 1";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                //Se obtiene el id correspondiente a la medicion se:
                int id_se_st = cdb.resultado.getInt("id_se_st");


                //Se guardan los resultados de la medición:
                ////////////////////////////////////////////
                // (1) Similitud Euclidiana TF_SN_ST
                ////////////////////////////////////////////

                Set set = ResultadosSETF_SN_ST.entrySet();
                Iterator iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_relacion_pagina, ArrayList<SE>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SE>:
                    List<Euclidiana> ListaSETF_SN = new ArrayList();
                    ListaSETF_SN = (List<Euclidiana>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSETF_SN.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        id_pagina_objetivo = ListaSETF_SN.get(i).getId_pagina_objetivo();
                        url_test = ListaSETF_SN.get(i).getUrl_test();
                        url_objetivo = ListaSETF_SN.get(i).getUrl_objetivo();
                        valor_se = ListaSETF_SN.get(i).getValor_se();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SETF_SN_ST ("
                                + "id_relacion_pag, "
                                + "id_se_st, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "setf_sn_st) "
                                + "VALUES ('" + id_relacion_pag + "','"
                                              + id_se_st + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_se + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores se

                }//FIN while páginas


                ////////////////////////////////////////////
                // (2) Similitud Euclidiana TF_N_ST
                ////////////////////////////////////////////
                set = ResultadosSETF_N_ST.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_relacion_pagina, ArrayList<SE>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SE>:
                    List<Euclidiana> ListaSETF_N = new ArrayList();
                    ListaSETF_N = (List<Euclidiana>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSETF_N.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        id_pagina_objetivo = ListaSETF_N.get(i).getId_pagina();
                        url_test = ListaSETF_N.get(i).getUrl_test();
                        url_objetivo = ListaSETF_N.get(i).getUrl_objetivo();
                        valor_se = ListaSETF_N.get(i).getValor_se();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SETF_N_ST ("
                                + "id_relacion_pag, "
                                + "id_se_st, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "setf_n_st) "
                                + "VALUES ('" + id_relacion_pag + "','"
                                              + id_se_st + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_se + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores se

                }//FIN while páginas



                ////////////////////////////////////////////
                // (3) Similitud Euclidiana TF_S_ST
                ////////////////////////////////////////////
                set = ResultadosSETF_S_ST.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_relacion_pagina, ArrayList<SE>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SE>:
                    List<Euclidiana> ListaSETF_S = new ArrayList();
                    ListaSETF_S = (List<Euclidiana>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSETF_S.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        id_pagina_objetivo = ListaSETF_S.get(i).getId_pagina_objetivo();
                        url_test = ListaSETF_S.get(i).getUrl_test();
                        url_objetivo = ListaSETF_S.get(i).getUrl_objetivo();
                        valor_se = ListaSETF_S.get(i).getValor_se();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SETF_S_ST("
                                + "id_relacion_pag, "
                                + "id_se_st, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "setf_s_st) "
                                + "VALUES ('" + id_relacion_pag + "','"
                                              + id_se_st + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_se + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores se

                }//FIN while páginas



                ////////////////////////////////////////////
                // (4) Similitud Euclidiana TFIDF_SN_ST
                ////////////////////////////////////////////
                set = ResultadosSETFIDF_SN_ST.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_relacion_pagina, ArrayList<SE>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SE>:
                    List<Euclidiana> ListaSETFIDF_SN = new ArrayList();
                    ListaSETFIDF_SN = (List<Euclidiana>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSETFIDF_SN.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        id_pagina_objetivo = ListaSETFIDF_SN.get(i).getId_pagina_objetivo();
                        url_test = ListaSETFIDF_SN.get(i).getUrl_test();
                        url_objetivo = ListaSETFIDF_SN.get(i).getUrl_objetivo();
                        valor_se = ListaSETFIDF_SN.get(i).getValor_se();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SETFIDF_SN_ST ("
                                + "id_relacion_pag, "
                                + "id_se_st, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "setfidf_sn_st) "
                                + "VALUES ('" + id_relacion_pag + "','"
                                              + id_se_st + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_se + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores se

                }//FIN while páginas



                //////////////////////////////////////////////
                // (5) Similitud Euclidiana TFIDF_N_ST
                //////////////////////////////////////////////
                set = ResultadosSETFIDF_N_ST.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_relacion_pag, ArrayList<SE>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SE>:
                    List<Euclidiana> ListaSETFIDF_N = new ArrayList();
                    ListaSETFIDF_N = (List<Euclidiana>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSETFIDF_N.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        id_pagina_objetivo = ListaSETFIDF_N.get(i).getId_pagina_objetivo();
                        url_test = ListaSETFIDF_N.get(i).getUrl_test();
                        url_objetivo = ListaSETFIDF_N.get(i).getUrl_objetivo();
                        valor_se = ListaSETFIDF_N.get(i).getValor_se();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SETFIDF_N_ST("
                                + "id_relacion_pag, "
                                + "id_se_st, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "setfidf_n_st) "
                                + "VALUES ('" + id_relacion_pag + "','"
                                              + id_se_st + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_se + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores se

                }//FIN while páginas




                ////////////////////////////////////////////
                // (6) Similitud Euclidiana TFIDF_S_ST
                ////////////////////////////////////////////
                set = ResultadosSETFIDF_S_ST.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_relacion_pag, ArrayList<SE>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SE>:
                    List<Euclidiana> ListaSETFIDF_S = new ArrayList();
                    ListaSETFIDF_S = (List<Euclidiana>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSETFIDF_S.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        id_pagina_objetivo = ListaSETFIDF_S.get(i).getId_pagina_objetivo();
                        url_test = ListaSETFIDF_S.get(i).getUrl_test();
                        url_objetivo = ListaSETFIDF_S.get(i).getUrl_objetivo();
                        valor_se = ListaSETFIDF_S.get(i).getValor_se();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SETFIDF_S_ST ("
                                + "id_relacion_pag, "
                                + "id_se_st, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "setfidf_s_st) "
                                + "VALUES ('" + id_relacion_pag + "','"
                                              + id_se_st + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_se + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores se

                }//FIN while páginas



                //////////////////////////////////////////////////
                // (7) Similitud Euclidiana TFIDF_O_SN_ST
                //////////////////////////////////////////////////
                set = ResultadosSETFIDF_O_SN_ST.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_relacion_pag, ArrayList<SE>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SE>:
                    List<Euclidiana> ListaSETFIDF_O_SN = new ArrayList();
                    ListaSETFIDF_O_SN = (List<Euclidiana>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSETFIDF_O_SN.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        id_pagina_objetivo = ListaSETFIDF_O_SN.get(i).getId_pagina_objetivo();
                        url_test= ListaSETFIDF_O_SN.get(i).getUrl_test();
                        url_objetivo = ListaSETFIDF_O_SN.get(i).getUrl_objetivo();
                        valor_se = ListaSETFIDF_O_SN.get(i).getValor_se();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SETFIDF_O_SN_ST ("
                                + "id_relacion_pag, "
                                + "id_se_st, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "setfidf_o_sn_st) "
                                + "VALUES ('" + id_relacion_pag + "','"
                                              + id_se_st + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_se + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores se

                }//FIN while páginas



                //////////////////////////////////////////////////
                // (8) Similitud Euclidiana TFIDF_O_N_ST
                //////////////////////////////////////////////////
                set = ResultadosSETFIDF_O_N_ST.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_relacion_pag, ArrayList<SE>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SE>:
                    List<Euclidiana> ListaSETFIDF_O_N = new ArrayList();
                    ListaSETFIDF_O_N = (List<Euclidiana>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSETFIDF_O_N.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        id_pagina_objetivo = ListaSETFIDF_O_N.get(i).getId_pagina_objetivo();
                        url_test = ListaSETFIDF_O_N.get(i).getUrl_test();
                        url_objetivo = ListaSETFIDF_O_N.get(i).getUrl_objetivo();
                        valor_se = ListaSETFIDF_O_N.get(i).getValor_se();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SETFIDF_O_N_ST ("
                                + "id_relacion_pag, "
                                + "id_se_st, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "setfidf_o_n_st) "
                                + "VALUES ('" + id_relacion_pag + "','"
                                              + id_se_st + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_se + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores se

                }//FIN while páginas



                ////////////////////////////////////////////////
                // (9) Similitud Euclidiana TFIDF_O_S_ST
                ////////////////////////////////////////////////
                set = ResultadosSETFIDF_O_N_ST.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_relacion_pag, ArrayList<SE>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SE>:
                    List<Euclidiana> ListaSETFIDF_O_S = new ArrayList();
                    ListaSETFIDF_O_S = (List<Euclidiana>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSETFIDF_O_S.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        id_pagina_objetivo = ListaSETFIDF_O_S.get(i).getId_pagina_objetivo();
                        url_test = ListaSETFIDF_O_S.get(i).getUrl_test();
                        url_objetivo = ListaSETFIDF_O_S.get(i).getUrl_objetivo();
                        valor_se = ListaSETFIDF_O_S.get(i).getValor_se();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SETFIDF_O_S_ST ("
                                + "id_relacion_pag, "
                                + "id_se_st, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "setfidf_o_s_st) "
                                + "VALUES ('" + id_relacion_pag + "','"
                                              + id_se_st + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_se + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores sc

                }//FIN while páginas



                /////////////////////////////////////////////
                // (10) Similitud Euclidiana OKAPI_ST
                /////////////////////////////////////////////
                set = ResultadosSEOKAPI_ST.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_relacion_pag, ArrayList<SE>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SE>:
                    List<Euclidiana> ListaSEOKAPI = new ArrayList();
                    ListaSEOKAPI = (List<Euclidiana>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSEOKAPI.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        id_pagina_objetivo = ListaSEOKAPI.get(i).getId_pagina_objetivo();
                        url_test = ListaSEOKAPI.get(i).getUrl_test();
                        url_objetivo = ListaSEOKAPI.get(i).getUrl_objetivo();
                        valor_se = ListaSEOKAPI.get(i).getValor_se();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SEOKAPI_ST ("
                                + "id_relacion_pag, "
                                + "id_se_st, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "seokapi_st) "
                                + "VALUES ('" + id_relacion_pag + "','"
                                              + id_se_st + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_se + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores se

                }//FIN while páginas


            }//FIN if
        }

    }//FIN GuardarSimilitudEuclidiana_ST


    /**
     * @brief Rankea los resultados obtenidos por la medición euclidiana para el texto alrededor.
     * @param Cantidad en el Ranking y la Consulta .
     * @return void
    */
    public void RankearMedicionSE_ST(int Ranking, String TopicoConsultado) throws InstantiationException, ClassNotFoundException, IllegalAccessException, IOException, SQLException
    {

        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        ////////////////////////////////////////////////////////
        //PASO 1: Se cargan las páginas segun ranking y umbral
        ////////////////////////////////////////////////////////
        int rankeo  = 1;
        int contador = 0;
        //Almacena <id_relacion_pag, rankeo>:
        HashMap<Integer,Integer> RankingPagina;
        //Fecha actual:
        java.util.Date fecha = new Date();


        ///////////////////////////////////////////////////////////////////////
        // (1) PARA SETF_SN_ST
        ///////////////////////

        //Almacena <id_relacion_pag, rankeo>:
        RankingPagina = new HashMap();

        cdb.un_sql = "SELECT * FROM MEDICION_SETF_SN_ST ORDER BY setf_sn_st ASC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            PrintWriter fileout = new PrintWriter(new FileWriter("RankingSETF_SN_ST.txt", true));

            fileout.println("***********************************************************");
            fileout.println("**  RANKING SIMILITUD EUCLIDIANA TF_SN  (SURROUND TEXT)  **");
            fileout.println("***********************************************************");
            fileout.println();
            fileout.println("FECHA: "+ fecha);
            fileout.println();
            fileout.println("CONSULTA: "+ TopicoConsultado);
            fileout.println();
            fileout.println("***************************************");

            while (cdb.resultado.next())
            {
                try {

                   //Se obtienen los campos de MEDICION_SETF_SN_ST:
                   int id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double setf_sn_st = cdb.resultado.getDouble("setf_sn_st");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      fileout.println("Posición: "+ rankeo);
                      fileout.println("Id_relacion_pag: " + id_relacion_pag);
                      fileout.println("Id_pagina_objetivo: "+ id_pagina_objetivo);
                      fileout.println("Url_test: "+ url_test);
                      fileout.println("Url_objetivo: "+ url_objetivo);
                      fileout.println("setf_sn: "+ setf_sn_st);
                      fileout.println("***************************************");
                      contador++;
                   }

                   RankingPagina.put(id_relacion_pag, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SETF_SN_ST.");
                }

            }
            fileout.close();
        }

        // Se Actualiza el raking:
        ActualizarRankingSETF_SN_ST(RankingPagina);


        ///////////////////////////////////////////////////////////////////////
        // (2) PARA SETF_N_ST
        ///////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_relacion_pag, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SETF_N_ST ORDER BY setf_n_st ASC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            PrintWriter fileout = new PrintWriter(new FileWriter("RankingSETF_N_ST.txt", true));

            fileout.println("**********************************************************");
            fileout.println("**  RANKING SIMILITUD EUCLIDIANA TF_N  (SURROUND TEXT)  **");
            fileout.println("**********************************************************");
            fileout.println();
            fileout.println("FECHA: "+ fecha);
            fileout.println();
            fileout.println("CONSULTA: "+ TopicoConsultado);
            fileout.println();
            fileout.println("***************************************");

            while (cdb.resultado.next())
            {
                try {

                   //Se obtienen los campos de MEDICION_SETF_N_ST:
                   int id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double setf_n_st = cdb.resultado.getDouble("setf_n_st");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      fileout.println("Posición: "+ rankeo);
                      fileout.println("Id_relacion_pag: " + id_relacion_pag);
                      fileout.println("Id_pagina_objetivo: "+ id_pagina_objetivo);
                      fileout.println("Url_test: "+ url_test);
                      fileout.println("Url_objetivo: "+ url_objetivo);
                      fileout.println("setf_n_st: "+ setf_n_st);
                      fileout.println("***************************************");
                      contador++;
                   }

                   RankingPagina.put(id_relacion_pag, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SETF_N_ST.");
                }

            }
            fileout.close();
        }

        // Se Actualiza el raking:
        ActualizarRankingSETF_N_ST(RankingPagina);


        ////////////////////////////////////////////////////////////////////////
        // (3) PARA SETF_S_ST
        ///////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_relacion_pag, rankeo>:
        RankingPagina = new HashMap();

        cdb.un_sql = "SELECT * FROM MEDICION_SETF_S_ST ORDER BY setf_s_st ASC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            PrintWriter fileout = new PrintWriter(new FileWriter("RankingSETF_S_ST.txt", true));

            fileout.println("**********************************************************");
            fileout.println("**  RANKING SIMILITUD EUCLIDIANA TF_S  (SURROUND TEXT)  **");
            fileout.println("**********************************************************");
            fileout.println();
            fileout.println("FECHA: "+ fecha);
            fileout.println();
            fileout.println("CONSULTA: "+ TopicoConsultado);
            fileout.println();
            fileout.println("***************************************");

            while (cdb.resultado.next())
            {
                try {

                   //Se obtienen los campos de MEDICION_SETF_S_ST:
                   int id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double setf_s_st = cdb.resultado.getDouble("setf_s_st");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      fileout.println("Posición: "+ rankeo);
                      fileout.println("Id_relacion_pag: " + id_relacion_pag);
                      fileout.println("Id_pagina_objetivo: "+ id_pagina_objetivo);
                      fileout.println("Url_test: "+ url_test);
                      fileout.println("Url_objetivo: "+ url_objetivo);
                      fileout.println("setf_s_st: "+ setf_s_st);
                      fileout.println("***************************************");
                      contador++;
                   }

                   RankingPagina.put(id_relacion_pag, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SETF_S_ST.");
                }

            }
            fileout.close();
        }

        // Se Actualiza el raking:
        ActualizarRankingSETF_S_ST(RankingPagina);


        ////////////////////////////////////////////////////////////////////////
        // (4) PARA SETFIDF_SN_ST
        /////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_relacion_pag, rankeo>:
        RankingPagina = new HashMap();

        cdb.un_sql = "SELECT * FROM MEDICION_SETFIDF_SN_ST ORDER BY setfidf_sn_st ASC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            PrintWriter fileout = new PrintWriter(new FileWriter("RankingSETFIDF_SN_ST.txt", true));

            fileout.println("**************************************************************");
            fileout.println("**  RANKING SIMILITUD EUCLIDIANA TFIDF_SN  (SURROUND TEXT)  **");
            fileout.println("**************************************************************");
            fileout.println();
            fileout.println("FECHA: "+ fecha);
            fileout.println();
            fileout.println("CONSULTA: "+ TopicoConsultado);
            fileout.println();
            fileout.println("***************************************");

            while (cdb.resultado.next())
            {
                try {

                   //Se obtienen los campos de MEDICION_SETFIDF_SN_ST:
                   int id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double setfidf_sn_st = cdb.resultado.getDouble("setfidf_sn_st");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      fileout.println("Posición: "+ rankeo);
                      fileout.println("Id_relacion_pag: " + id_relacion_pag);
                      fileout.println("Id_pagina_objetivo: "+ id_pagina_objetivo);
                      fileout.println("Url_test: "+ url_test);
                      fileout.println("Url_objetivo: "+ url_objetivo);
                      fileout.println("setfidf_sn_st: "+ setfidf_sn_st);
                      fileout.println("***************************************");
                      contador++;
                   }

                   RankingPagina.put(id_relacion_pag, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SETFIDF_SN_ST .");
                }

            }
            fileout.close();
        }

        // Se Actualiza el raking:
        ActualizarRankingSETFIDF_SN_ST(RankingPagina);


        ////////////////////////////////////////////////////////////////////////
        // (5) PARA SETFIDF_N_ST
        /////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_relacion_pag, rankeo>:
        RankingPagina = new HashMap();

        cdb.un_sql = "SELECT * FROM MEDICION_SETFIDF_N_ST ORDER BY setfidf_n_st ASC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            PrintWriter fileout = new PrintWriter(new FileWriter("RankingSETFIDF_N_ST.txt", true));

            fileout.println("*************************************************************");
            fileout.println("**  RANKING SIMILITUD EUCLIDIANA TFIDF_N  (SURROUND TEXT)  **");
            fileout.println("*************************************************************");
            fileout.println();
            fileout.println("FECHA: "+ fecha);
            fileout.println();
            fileout.println("CONSULTA: "+ TopicoConsultado);
            fileout.println();
            fileout.println("***************************************");

            while (cdb.resultado.next())
            {
                try {

                   //Se obtienen los campos de MEDICION_SETFIDF_N_ST:
                   int id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double setfidf_n_st = cdb.resultado.getDouble("setfidf_n_st");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      fileout.println("Posición: "+ rankeo);
                      fileout.println("Id_relacion_pag: " + id_relacion_pag);
                      fileout.println("Id_pagina_objetivo: "+ id_pagina_objetivo);
                      fileout.println("Url_test: "+ url_test);
                      fileout.println("Url_objetivo: "+ url_objetivo);
                      fileout.println("setfidf_n_st: "+ setfidf_n_st);
                      fileout.println("***************************************");
                      contador++;
                   }

                   RankingPagina.put(id_relacion_pag, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SETFIDF_N_ST .");
                }

            }
            fileout.close();
        }

        // Se Actualiza el raking:
        ActualizarRankingSETFIDF_N_ST(RankingPagina);



        ////////////////////////////////////////////////////////////////////////
        // (6) PARA SETFIDF_S_ST
        /////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_relacion_pag, rankeo>:
        RankingPagina = new HashMap();

        cdb.un_sql = "SELECT * FROM MEDICION_SETFIDF_S_ST ORDER BY setfidf_s_st ASC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            PrintWriter fileout = new PrintWriter(new FileWriter("RankingSETFIDF_S_ST.txt", true));

            fileout.println("*************************************************************");
            fileout.println("**  RANKING SIMILITUD EUCLIDIANA TFIDF_S  (SURROUND TEXT)  **");
            fileout.println("*************************************************************");
            fileout.println();
            fileout.println("FECHA: "+ fecha);
            fileout.println();
            fileout.println("CONSULTA: "+ TopicoConsultado);
            fileout.println();
            fileout.println("***************************************");

            while (cdb.resultado.next())
            {
                try {

                   //Se obtienen los campos de MEDICION_SETFIDF_N_ST:
                   int id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double setfidf_s_st = cdb.resultado.getDouble("setfidf_s_st");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      fileout.println("Posición: "+ rankeo);
                      fileout.println("Id_relacion_pag: " + id_relacion_pag);
                      fileout.println("Id_pagina_objetivo: "+ id_pagina_objetivo);
                      fileout.println("Url_test: "+ url_test);
                      fileout.println("Url_objetivo: "+ url_objetivo);
                      fileout.println("setfidf_s_st: "+ setfidf_s_st);
                      fileout.println("***************************************");
                      contador++;
                   }

                   RankingPagina.put(id_relacion_pag, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SETFIDF_S_ST .");
                }

            }
            fileout.close();
        }

        // Se Actualiza el raking:
        ActualizarRankingSETFIDF_S_ST(RankingPagina);


        ////////////////////////////////////////////////////////////////////////
        // (7) PARA SETFIDF_O_SN_ST
        ////////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_relacion_pag, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SETFIDF_O_SN_ST ORDER BY setfidf_o_sn_st ASC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            PrintWriter fileout = new PrintWriter(new FileWriter("RankingSETFIDF_O_SN_ST.txt", true));

            fileout.println("****************************************************************");
            fileout.println("**  RANKING SIMILITUD EUCLIDIANA TFIDF_O_SN  (SURROUND TEXT)  **");
            fileout.println("****************************************************************");
            fileout.println();
            fileout.println("FECHA: "+ fecha);
            fileout.println();
            fileout.println("CONSULTA: "+ TopicoConsultado);
            fileout.println();
            fileout.println("***************************************");

            while (cdb.resultado.next())
            {
                try {

                   //Se obtienen los campos de MEDICION_SETFIDF_N_ST:
                   int id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double setfidf_o_sn_st = cdb.resultado.getDouble("setfidf_o_sn_st");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      fileout.println("Posición: "+ rankeo);
                      fileout.println("Id_relacion_pag: " + id_relacion_pag);
                      fileout.println("Id_pagina_objetivo: "+ id_pagina_objetivo);
                      fileout.println("Url_test: "+ url_test);
                      fileout.println("Url_objetivo: "+ url_objetivo);
                      fileout.println("setfidf_o_sn_st: "+ setfidf_o_sn_st);
                      fileout.println("***************************************");
                      contador++;
                   }

                   RankingPagina.put(id_relacion_pag, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SETFIDF_O_SN_ST .");
                }

            }
            fileout.close();
        }

        // Se Actualiza el raking:
        ActualizarRankingSETFIDF_O_SN_ST(RankingPagina);


        ////////////////////////////////////////////////////////////////////////
        // (8) PARA SETFIDF_O_N_ST
        ////////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_relacion_pag, rankeo>:
        RankingPagina = new HashMap();

        cdb.un_sql = "SELECT * FROM MEDICION_SETFIDF_O_N_ST ORDER BY setfidf_o_n_st ASC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            PrintWriter fileout = new PrintWriter(new FileWriter("RankingSETFIDF_O_N_ST.txt", true));

            fileout.println("***************************************************************");
            fileout.println("**  RANKING SIMILITUD EUCLIDIANA TFIDF_O_N  (SURROUND TEXT)  **");
            fileout.println("***************************************************************");
            fileout.println();
            fileout.println("FECHA: "+ fecha);
            fileout.println();
            fileout.println("CONSULTA: "+ TopicoConsultado);
            fileout.println();
            fileout.println("***************************************");

            while (cdb.resultado.next())
            {
                try {

                   //Se obtienen los campos de MEDICION_SETFIDF_N_ST:
                   int id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double setfidf_o_n_st = cdb.resultado.getDouble("setfidf_o_n_st");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      fileout.println("Posición: "+ rankeo);
                      fileout.println("Id_relacion_pag: " + id_relacion_pag);
                      fileout.println("Id_pagina_objetivo: "+ id_pagina_objetivo);
                      fileout.println("Url_test: "+ url_test);
                      fileout.println("Url_objetivo: "+ url_objetivo);
                      fileout.println("setfidf_o_n_st: "+ setfidf_o_n_st);
                      fileout.println("***************************************");
                      contador++;
                   }

                   RankingPagina.put(id_relacion_pag, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SETFIDF_O_N_ST .");
                }

            }
            fileout.close();
        }

        // Se Actualiza el raking:
        ActualizarRankingSETFIDF_O_N_ST(RankingPagina);



        ////////////////////////////////////////////////////////////////////////
        // (9) PARA SETFIDF_O_S_ST
        ////////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_relacion_pag, rankeo>:
        RankingPagina = new HashMap();

        cdb.un_sql = "SELECT * FROM MEDICION_SETFIDF_O_S_ST ORDER BY setfidf_o_s_st ASC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            PrintWriter fileout = new PrintWriter(new FileWriter("RankingSETFIDF_O_S_ST.txt", true));

            fileout.println("***************************************************************");
            fileout.println("**  RANKING SIMILITUD EUCLIDIANA TFIDF_O_S  (SURROUND TEXT)  **");
            fileout.println("***************************************************************");
            fileout.println();
            fileout.println("FECHA: "+ fecha);
            fileout.println();
            fileout.println("CONSULTA: "+ TopicoConsultado);
            fileout.println();
            fileout.println("***************************************");

            while (cdb.resultado.next())
            {
                try {

                   //Se obtienen los campos de MEDICION_SETFIDF_N_ST:
                   int id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double setfidf_o_s_st = cdb.resultado.getDouble("setfidf_o_s_st");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      fileout.println("Posición: "+ rankeo);
                      fileout.println("Id_relacion_pag: " + id_relacion_pag);
                      fileout.println("Id_pagina_objetivo: "+ id_pagina_objetivo);
                      fileout.println("Url_test: "+ url_test);
                      fileout.println("Url_objetivo: "+ url_objetivo);
                      fileout.println("setfidf_o_s_st: "+ setfidf_o_s_st);
                      fileout.println("***************************************");
                      contador++;
                   }

                   RankingPagina.put(id_relacion_pag, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SETFIDF_O_S_ST .");
                }

            }
            fileout.close();
        }

        // Se Actualiza el raking:
        ActualizarRankingSETFIDF_O_S_ST(RankingPagina);



        ////////////////////////////
        // (10) PARA SEOKAPI
        ////////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_relacion_pag, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SEOKAPI_ST ORDER BY seokapi_st ASC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            PrintWriter fileout = new PrintWriter(new FileWriter("RankingSEOKAPI_ST.txt", true));

            fileout.println("***********************************************************");
            fileout.println("**  RANKING SIMILITUD EUCLIDIANA OKAPI  (SURROUND TEXT)  **");
            fileout.println("***********************************************************");
            fileout.println();
            fileout.println("FECHA: "+ fecha);
            fileout.println();
            fileout.println("CONSULTA: "+ TopicoConsultado);
            fileout.println();
            fileout.println("***************************************");

            while (cdb.resultado.next())
            {
                try {

                   //Se obtienen los campos de MEDICION_SETFIDF_N_ST:
                   int id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double seokapi_st = cdb.resultado.getDouble("seokapi_st");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      fileout.println("Posición: "+ rankeo);
                      fileout.println("Id_relacion_pag: " + id_relacion_pag);
                      fileout.println("Id_pagina_objetivo: "+ id_pagina_objetivo);
                      fileout.println("Url_test: "+ url_test);
                      fileout.println("Url_objetivo: "+ url_objetivo);
                      fileout.println("seokapi_st: "+ seokapi_st);
                      fileout.println("***************************************");
                      contador++;
                   }

                   RankingPagina.put(id_relacion_pag, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SEOKAPI_ST .");
                }

            }
            fileout.close();
        }

        // Se Actualiza el raking:
        ActualizarRankingSEOKAPI_ST(RankingPagina);



    }//FIN RankearMedicionSE_ST

    private void ActualizarRankingSETF_SN_ST(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SETF_SN_ST SET ranking_setf_sn_st = '" + me.getValue() + "' WHERE id_relacion_pag = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSETF_SN_ST

    private void ActualizarRankingSETF_N_ST(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SETF_N_ST SET ranking_setf_n_st = '" + me.getValue() + "' WHERE id_relacion_pag = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSETF_N_ST

    private void ActualizarRankingSETF_S_ST(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SETF_S_ST SET ranking_setf_s_st = '" + me.getValue() + "' WHERE id_relacion_pag = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSETF_S_ST

    private void ActualizarRankingSETFIDF_SN_ST(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SETFIDF_SN_ST SET ranking_setfidf_sn_st = '" + me.getValue() + "' WHERE id_relacion_pag = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSETFIDF_SN_ST

    private void ActualizarRankingSETFIDF_N_ST(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SETFIDF_N_ST SET ranking_setfidf_n_st = '" + me.getValue() + "' WHERE id_relacion_pag = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSETFIDF_N_ST

    private void ActualizarRankingSETFIDF_S_ST(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SETFIDF_S_ST SET ranking_setfidf_s_st = '" + me.getValue() + "' WHERE id_relacion_pag = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSETFIDF_S_ST

    private void ActualizarRankingSETFIDF_O_SN_ST(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SETFIDF_O_SN_ST SET ranking_setfidf_o_sn_st = '" + me.getValue() + "' WHERE id_relacion_pag = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSETFIDF_O_SN_ST

    private void ActualizarRankingSETFIDF_O_N_ST(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SETFIDF_O_N_ST SET ranking_setfidf_o_n_st = '" + me.getValue() + "' WHERE id_relacion_pag = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSETFIDF_O_N_ST

    private void ActualizarRankingSETFIDF_O_S_ST(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SETFIDF_O_S_ST SET ranking_setfidf_o_s_st = '" + me.getValue() + "' WHERE id_relacion_pag = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSETFIDF_O_S_ST

    private void ActualizarRankingSEOKAPI_ST(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SEOKAPI_ST SET ranking_seokapi_st = '" + me.getValue() + "' WHERE id_relacion_pag = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSEOKAPI_ST

}//FIN CLASE EuclidianaBD